package com.luo.solr.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.logging.log4j.util.Strings;
import org.apache.solr.client.solrj.beans.Field;
import org.springframework.data.solr.core.mapping.SolrDocument;

import java.io.Serializable;
import java.util.HashMap;
import java.util.Set;

/**
 * @Auther: 罗健康
 * @Date: 2020/11/13 17:13
 * @Description:
 */

@Data
@AllArgsConstructor
@NoArgsConstructor
/**
 可以在实体类上添加上@SolrDocument(solrCoreName = "custom_core")这个注解，
 表明这个实体类可以转换成SolrDocument对象，此外一定不要忘了指定core的名称。
 如果实体类属性和solr的field对应不上，可以使用@Field(value="field名称")注解，
 实现实体类和solr field之间的对应关系。
 **/
@SolrDocument(solrCoreName = "mycore")
public class User implements Serializable {

    public static void main(String[] args) {

        new A();

        /*int [] a = {1,6,8,7,3,5,16,4,8,36,13,44};
        QKSort(a,0,a.length-1);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }*/
       /* String s = "abrcdkkr";
        HashMap<String, Integer> map = test(s);
        HashMap<String, Integer> map1 = test1("abc", "abcbac");
        Set<String> set = map1.keySet();
        for (String s1 : set) {
            System.out.println(s1+": "+map1.get(s1));
        }*/
    }

    /**
     *  统计s1中每一个字符在s2中出现的次数
     **/
    private static HashMap<String, Integer> test1(String s1,String s2){
        HashMap<String,Integer> map = new HashMap<>(16);
        for (int i = 0; i < s1.length(); i++) {
            char c = s1.charAt(i);
            int num = testCount(s2,c);
            map.put(String.valueOf(c),num);
        }
        return map;
    }

    //统计一个字符在字符串中出现的次数
    private static int testCount(String s,char ch){
        int count = 0;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c==ch){
                count++;
            }
        }
        return count;
    }


    /*
     *  统计一个字符串中各个字符出现的次数
     **/
    private static HashMap<String, Integer> test(String s){
        HashMap<String,Integer> map = new HashMap<>(16);
        for (int i = 0; i < s.length(); i++) {
            String s1 = String.valueOf(s.charAt(i));
            //查看key是否包含s1
            if (!map.containsKey(s1)){
                map.put(s1,1);
            }else {
                //包含+1
                Integer count = map.get(s1);
                map.put(s1,++count);
            }
        }
        return map;
    }


    //一般左边第一个为基准数，从右边开始判断，先从右边检索比基准数小的，检索到了，停下，
    // 在从左边检索比基准数大的，检索到了就停下，交换
    //一旦i和j相遇，停止检索，交换基数和相遇位置的数，第一轮结束
    //分别对基数左边 和  右边进行排序

    private static void QKSort(int[] arr, int left, int right) {
        //检查安全性
        if (left>right){
            return;
        }

        int j =right;
        int i =left ;
        int base = arr[left];
        //一旦i和j相遇，停止检索，交换基数和相遇位置的数，第一轮结束
        while (i!=j){
            //先从右边检索比基准数小的，比基准数大就往左移动
            while (arr[j]>=base && i<j){
                j--; //从右往左移动
            }
            // 在从左边检索比基准数大的，比基准数大就往右移动
            while (arr[i]<= base && i< j){
                i++; //i 从左往右移动
            }
            swap(arr,i,j);
        }
        //一旦i和j相遇，停止检索，交换基数和相遇位置的数，第一轮结束
        arr[left]=arr[i];
        arr[i] = base;

        QKSort(arr,left,i-1);
        QKSort(arr,j+1,right);
    }
    // i的值 和 j的值 位置进行交换
    private static void swap(int[] array,int i,int j){
        int temp=array[i];
        array[i]=array[j];
        array[j]=temp;
    }

    //必须实现可序列化接口，要在网络上传输
    @Field("id")//使用这个注释，里面的名字是根据你在solr数据库中配置的来决定
    private String id;
    @Field("name")
    private String name;
    @Field("sex")
    private String sex;
    @Field("address")
    private String address;
}